home *** CD-ROM | disk | FTP | other *** search
/ Almathera Ten Pack 3: CDPD 3 / Almathera Ten on Ten - Disc 3: CDPD3.iso / ab20 / unarced / utilities / shells / csh / rawcon.c < prev    next >
C/C++ Source or Header  |  1995-03-17  |  19KB  |  887 lines
  1. /* rawcon.c
  2.  *
  3.  * Shell 2.07M  17-Jun-87
  4.  * console handling, command line editing support for Shell
  5.  * using new console packets from 1.2.
  6.  * Written by Steve Drew. (c) 14-Oct-86.
  7.  * 16-Dec-86 Slight mods to rawgets() for Disktrashing.
  8.  *
  9.  * Version 4.01A by Carlo Borreo & Cesare Dieni 17-Feb-90
  10.  * Version 5.00L by Urban Mueller 17-Feb-91
  11.  */
  12.  
  13. #include "shell.h"
  14.  
  15. void setrawcon( long flag, int ievent );
  16.  
  17. #define LINELEN 255
  18.  
  19. int w_width=80, w_height=24;
  20.  
  21. #if RAW_CONSOLE
  22.  
  23. static int myget( void );
  24. static void myunget(int c);
  25. static int get_seq( long *param );
  26.  
  27. static void back( int n );
  28. static void left( int n );
  29. static void right( int n );
  30. static int  leftwordlen( void );
  31. static int  rightwordlen( void );
  32. static void delete( int i );
  33. static void history( int hnum );
  34. static void display( char *str );
  35. static void redraw( void );
  36. static void abbrev( char *buf, char **eav, int eac );
  37. static void quote( char *buf, char *sep );
  38. static void getword( char *buf );
  39. static void delword( void );
  40. static int  getkey(void);
  41.  
  42. static char *tyahdptr;
  43. static int unget;
  44.  
  45. #define SETRAW setrawcon(-1,1);
  46. #define SETCON setrawcon( 0,1);
  47.  
  48. extern char *MenuCommand[MAXMENUS][MAXITEMS];
  49.  
  50. #define CTRL  -64
  51. #define SHIFT 512
  52. #define ESC   1024
  53.  
  54. #define CUP   256
  55. #define CDN   257
  56. #define CRT   258
  57. #define CLT   259
  58. #define TAB   9
  59.  
  60. static int Curmap;
  61. static USHORT *Keymap[8];
  62. static USHORT DefKeymap0[]={
  63.        CLT,  0, /* CursLt = Move.Left  */
  64.        CRT,  1, /* CursRt = Move.Right */
  65.  SHIFT+CLT,  2, /* SCursLt= Move.WordL */
  66.  SHIFT+CRT,  3, /* SCursRt= Move.WordR */
  67.    ESC+CLT,  4, /* ESC-CLt= Move.SOL   */
  68.    ESC+CRT,  5, /* ESC-CRt= Move.EOL   */
  69.   CTRL+'A',  4, /* ^A     = Move.SOL   */
  70.   CTRL+'E',  5, /* ^E     = Move.EOL   */
  71.   CTRL+'Z',  4, /* ^Z     = Move.SOL   */
  72.          8, 10, /* BackSp = Del.BackSp */
  73.        127, 11, /* Delete = Del.Delete */
  74.    ESC+  8, 12, /* ESC-BkS= Del.WordL  */
  75.    ESC+127, 13, /* ESC-Del= Del.WordR  */
  76.   CTRL+'W', 12, /* ^W     = Del.WordL  */
  77.   CTRL+'B', 14, /* ^B     = Del.SOL    */
  78.   CTRL+'K', 15, /* ^K     = Del.EOL    */
  79.    ESC+'x',513, /* ESC-x  = Setmap 1   */
  80.    ESC+'d', 16, /* ESC-d  = Del.Line   */
  81.   CTRL+'X', 16, /* ^X     = Del.Line   */
  82.        CUP, 20, /* CursUp = Hist.Back  */
  83.        CDN, 21, /* CursDn = Hist.Forw  */
  84.    ESC+CUP, 22, /* ECursUp= Hist.Beg   */
  85.    ESC+CDN, 23, /* ECursDn= Hist.End   */
  86.  SHIFT+CUP, 24, /* SCursUp= Hist.Compl */
  87.    ESC+'!', 24, /* ESC-!  = Hist.Compl */
  88.    ESC+ 13, 25, /* ESC-Ret= Hist.Exec  */
  89.   CTRL+'T', 26, /* ^T     = Hist.Tail  */
  90.  SHIFT+CDN, 27, /* SCursDn= Hist.Clr   */
  91.   CTRL+'P', 28, /* ^P     = Hist.DupWrd*/
  92.        TAB, 30, /* Tab    = Comp.Norm  */
  93.  SHIFT+TAB, 31, /* STab   = Comp.Part  */
  94.    ESC+TAB, 32, /* ESC-TAB= Comp.All   */
  95.    ESC+'*', 32, /* ESC-*  = Comp.All   */
  96.    ESC+'c', 33, /* ESC-c  = Comp.CD    */
  97.    ESC+'~', 34, /* ESC-~  = Comp.LastCD*/
  98.   CTRL+'D', 35, /* CTRL-D = Comp.Dir   */
  99.    ESC+'=', 35, /* ESC-=  = Comp.Dir   */
  100.    ESC+'i', 40, /* ESC-i  = Spec.Insert*/
  101.   CTRL+'L', 43, /* ^L     = Spec.Refr  */
  102.         10, 44, /* Enter  = Spec.Accept*/
  103.         13, 44, /* ^Enter = Spec.Accept*/
  104.   CTRL+'N', 45, /* ^N     = Spec.Next  */
  105.   CTRL+'O', 48, /* ^O     = Spec.EchoO */
  106.  CTRL+'\\', 46, /* ^\     = Spec.EOF   */
  107.        260, 42, /* Help   = Spec.Help  */
  108.        271, 51, /* Menu   = Misc.Menu  */
  109.   CTRL+'U', 52, /* ^U     = Misc.Undo  */
  110.   CTRL+'R', 53, /* ^R     = Misc.Repeat*/
  111.    ESC+'s', 54, /* ESC-s  = Misc.Swap  */
  112.          0,  0
  113. };
  114.  
  115. static USHORT DefKeymap1[]={
  116.          8, 14,
  117.        127, 15
  118. };
  119.  
  120. static int  Pos, Len;
  121. static char *Line, *Prompt;
  122. static char LastDir[128];
  123. static char Undo[256];
  124. static int  LastFn=-99, LastKey=-99;
  125. long   Param[10];
  126.  
  127. void
  128. initmap(void)
  129. {
  130.     if( !Keymap[0] )
  131.         Keymap[0]=DefKeymap0, Keymap[1]=DefKeymap1;
  132. }
  133.  
  134. char *
  135. rawgets( char line[], char prompt[] )
  136. {
  137.     static int HNum=-1;
  138.  
  139.     int  key, fn, old, hnum=-1, olen=0, inslen=0;
  140.     int  insert, undo_pos=0, undo_len=0;
  141.     int  eac, eactr=0;
  142.     char typeahd[LINELEN], **eav=NULL, *ret=line;
  143.  
  144.     if ( o_noraw || !isconsole(Input()) ) {
  145.         if( isconsole(Input())) {
  146.             printf("%s",prompt);
  147.             fflush(stdout);
  148.         }
  149.         return gets(line);
  150.     }
  151.  
  152.     if (WaitForChar(Input(), 100L) || CHARSWAIT(stdin)) /* don't switch to 1 */
  153.         return gets(line);
  154.  
  155.     SETRAW;
  156.  
  157.     tyahdptr=typeahd;
  158.     typeahd[0]=0;
  159.     printf("\015%s",prompt);
  160.  
  161.     Line= line; Prompt= prompt;
  162.     line[ Len=Pos=0 ]=0;
  163.     insert= o_insert;
  164.  
  165.     if( LastFn!=25 )
  166.         LastFn=-1;
  167.  
  168.     if( HNum>=0 ) {
  169.         history( hnum=HNum );
  170.         HNum=-1;
  171.     }
  172.  
  173.     while( (key=getkey()) != -1) {
  174.         USHORT *p;
  175.         int    t;
  176.         char   c, *s, *src, *sep;
  177.  
  178.         for( fn=-1, p=Keymap[Curmap]; *p; p+=2 )
  179.             if( *p==key )
  180.                 { fn=p[1]; break; }
  181.         if( fn==-1 && (key>=261 && key<=270 || key>=261+SHIFT && key<=270+SHIFT))
  182.             fn=50;
  183.         if( fn==-1 && tyahdptr )
  184.             fn=-2;
  185.         if( fn!=52 && fn!=-2 ) {
  186.             memcpy( Undo, line, Len+1 );
  187.             undo_pos=Pos; undo_len=Len;
  188.         }
  189.  
  190.         switch( fn/512 ) {
  191.         case 1:
  192.             fn&=511;
  193.             if( fn<8 && Keymap[fn] ) Curmap=fn;
  194.             fn=-3;
  195.             break;
  196.         case 2:
  197.             key=fn&511, fn=-1;
  198.             break;
  199.         }
  200.  
  201.         if( fn!=-3 )
  202.             Curmap=0;
  203.  
  204.         if( fn==53 )
  205.             fn=LastFn, key=LastKey;
  206.  
  207.         switch( fn ) {
  208.         case -3:                                /* change keymap */
  209.             break;
  210.         case -2:                                /* auto insert   */
  211.         case -1:                                /* insert key    */
  212.             key&=255;
  213.             if (key < 31 || (insert?Len:Pos) >= LINELEN-1 )
  214.                 break;
  215.             putchar(key);
  216.             if (Pos < Len && insert) {
  217.                 memmove( line+Pos+1, line+Pos, Len-Pos+1);
  218.                 printf("%s",line+Pos+1);
  219.                 back(Len-Pos);
  220.                 Len++;
  221.             }
  222.             line[Pos++] = key;
  223.             if (Len < Pos) Len = Pos;
  224.             line[Len] = 0;
  225.             break;
  226.  
  227.         case 0:                                 /* cursor left  */
  228.             left(1);
  229.             break;
  230.         case 1:                                 /* cursor right */
  231.             right(1);
  232.             break;
  233.         case 2:                                 /* word left    */
  234.             left( leftwordlen() );
  235.             break;
  236.         case 3:                                 /* word right   */
  237.             right( rightwordlen() );
  238.             break;
  239.         case 4:                                 /* beg of line  */
  240.             left(Pos);
  241.             break;
  242.         case 5:                                 /* end of line  */
  243.             right(Len-Pos);
  244.             break;
  245.  
  246.         case 10:                                /* backspace    */
  247.             if (Pos==0)
  248.                 break;
  249.             left(1);
  250.         case 11:                                /* delete       */
  251.             if (Pos==Len)
  252.                 break;
  253.             delete(1);
  254.             break;
  255.         case 12:                                /* bkspc word     */
  256.             if( !leftwordlen() )
  257.                 break;
  258.             left( leftwordlen() );
  259.         case 13:                                /* del word       */
  260.             delete( rightwordlen() );
  261.             break;
  262.         case 14:                                /* del to SOL     */
  263.             left( old=Pos );
  264.             delete( old );
  265.             break;
  266.         case 16:                                /* delete line    */
  267.             left( Pos );
  268.         case 15:                                /* delete to EOL  */
  269.             delete( Len-Pos );
  270.             break;
  271.  
  272.         case 20:                                /* history up   */
  273.             if( hnum>=H_len-1 )
  274.                 hnum=H_len-1;
  275.             history( ++hnum );
  276.             break;
  277.         case 21:                                /* history down */
  278.             if( hnum<=0 )
  279.                 hnum=0;
  280.             history( --hnum );
  281.             break;
  282.         case 22:                                /* beg of hist */
  283.             history( hnum=H_len-1 );
  284.             break;
  285.         case 23:                                /* end of hist */
  286.             history( hnum=0 );
  287.             break;
  288.         case 24:                                /* complete hist */
  289.             if( LastFn!=fn )
  290.                 hnum=-1, olen=Len;
  291.             line[Len=olen]=0;
  292.             if((hnum=find_history( line, ++hnum ))==-1)
  293.                 display(line);
  294.             else 
  295.                 history(hnum);
  296.             break;
  297.         case 25:                                /* exec hist  */
  298.             HNum= hnum;
  299.             LastFn= fn;
  300.             goto done;
  301.         case 26:                                /* tail of prev */
  302.             if( H_head && (s=H_head->line) && (s=index(s,' ')))
  303.                 tyahdptr=s;
  304.             break;
  305.         case 27:                                /* bottom   */
  306.             history( hnum=-1 );
  307.             break;
  308.         case 28:                                /* duplicate word */
  309.             for( s=line+Pos,t=0; s>line && s[-1]==' '; s--,t++ ) ;
  310.             left(t);
  311.             *(tyahdptr=typeahd)=' ';
  312.             getword( typeahd+(t?0:1) );
  313.             right(t);
  314.             break;
  315.  
  316.         case 32:                                /* complete all  */
  317.         case 35: LastFn=-1;                     /* show files    */
  318.         case 30:                                /* complete      */
  319.         case 31:                                /* complete part */
  320.         case 33:                                /* qcd           */
  321.             sep=" ";
  322.             if( fn!=LastFn ) {
  323.                 getword( typeahd );
  324.                 filemap( typeahd, 1 );
  325.                 if( eav    ) free_expand( eav ), eav=NULL;
  326.                 eac=0;
  327.                 breakreset();
  328.                 if( fn==35 ) {
  329.                     int tmp=o_scroll;
  330.                     right(Len-Pos);
  331.                     putchar('\n');
  332.                     memmove( typeahd+7, typeahd, strlen(typeahd)+1);
  333.                     memcpy ( typeahd, "dir -s ", 7);
  334.                     o_scroll=0;
  335.                     execute( typeahd );
  336.                     o_scroll=tmp;
  337.                     printf("\033[J%s%s",Prompt,Line);
  338.                     back(Len-Pos);
  339.                     break;
  340.                 }
  341.                 if( fn!=33 ) {
  342.                     strcat(  typeahd, "*");
  343.                     if( !index(typeahd,'&' ))
  344.                         eav =expand(typeahd,&eac);
  345.                     if( eac==0 ) {
  346.                         putchar(7);
  347.                         break;
  348.                     }
  349.                 }
  350.                 if( fn==30 )
  351.                     s=eav[ eactr=0 ];
  352.                 else if( fn==31 )
  353.                     abbrev(s=typeahd,eav,eac), eactr=-1, sep= eac==1?" ":"";
  354.                 else if( fn==32 ) {
  355.                     strncpy(s=typeahd, src=compile_av(eav,0,eac,' ',1),LINELEN);
  356.                     typeahd[LINELEN-1]=0;
  357.                     free(src);
  358.                 } else if( fn==33 ) {     /* 33 */
  359.                     strncpy(LastDir,typeahd,128);
  360.                     if( !quick_cd( s=typeahd+128, LastDir, 0)) {
  361.                         putchar(7);
  362.                         break;
  363.                     }
  364.                 }
  365.                 delword();
  366.             } else {
  367.                 if( fn==33 ) 
  368.                     quick_cd( s=typeahd+128, LastDir, 1);
  369.                 else { /* 30,31 */
  370.                     if( eac==0 ) {
  371.                         putchar(7);
  372.                         break;
  373.                     }
  374.                     s=eav[eactr=++eactr % eac];
  375.                 }
  376.                 left(inslen);
  377.                 delete(inslen);
  378.             }
  379.             strcpy( tyahdptr=typeahd, s );
  380.             if( fn!=32 )
  381.                 quote( typeahd, sep ); 
  382.             inslen=strlen(typeahd);
  383.             break;
  384.         case 34:                      /* last CD */
  385.             strncpy(typeahd,get_var( LEVEL_SET, v_lcd ),230);
  386.             appendslash(tyahdptr=typeahd);
  387.             break;
  388.  
  389.         case 40:                      /* ins/ovr */
  390.             insert ^= 1;
  391.             break;
  392.         case 41:                      /* quit    */
  393.             strcpy(line,"quit");
  394.             goto done;
  395.         case 42:                      /* help    */
  396.             strcpy(line,"help");
  397.             goto done;
  398.         case 43:                      /* refresh */
  399.             redraw();
  400.             break;
  401.         case 44:                      /* exec    */
  402.             goto done;
  403.         case 45:                      /* leave   */
  404.             add_history( line );
  405.             right(Len-Pos);
  406.             putchar('\n');
  407.             line[Len=Pos=0]=0;
  408.             update_sys_var(v_prompt);
  409.             update_sys_var(v_titlebar);
  410.             redraw();
  411.             hnum=-1;
  412.             break;
  413.         case 46:                      /* EOF */
  414.             ret=NULL;
  415.             goto done;
  416.         case 47:                      /* NOP */
  417.             break;
  418.         case 48:                      /* ^O  */
  419.             putchar( CTRL+'O' );
  420.             redraw();
  421.             break;
  422.         case 49:                      /* ^G  */
  423.             putchar( CTRL+'G' );
  424.             break;
  425.  
  426.         case 50:                      /* FKey */
  427.             sprintf(typeahd,"%c%d",Param[0]>=10?'F':'f',Param[0]%10+1);
  428.             if (s = get_var(LEVEL_SET, typeahd)) {
  429.                 tyahdptr = strcpy(typeahd,s);
  430.                 a0tospace( tyahdptr );
  431.             }
  432.             break;
  433.         case 51:                      /* RawRaw */
  434.             if( Param[0]==10 ) {   /* P0=class P2=code */
  435.                 int num=MENUNUM( Param[2] ), item=ITEMNUM( Param[2] );
  436.                 tyahdptr="";
  437.                 if( num>=0 && num<MAXMENUS && item>=0 && item<=MAXITEMS )
  438.                     tyahdptr=MenuCommand[num][item];                                 
  439.             }
  440.             if( Param[0]==11 ) {
  441.                 strcpy(line,"quit");
  442.                 goto done;
  443.             }
  444.             break;
  445.         case 52:                      /* Undo   */
  446.             back(Pos);
  447.             t=Len; Len=undo_len; undo_len=t;
  448.             t=Pos; Pos=undo_pos; undo_pos=t;
  449.             swapmem( Undo, line, MAX( Len, undo_len)+1 );
  450.             printf("\033[J%s",line);
  451.             back(Len-Pos);
  452.             break;
  453.         case 53:                      /* repeat */
  454.             break;
  455.         case 54:                      /* swap   */
  456.             if( (t=Pos==Len?Pos-1:Pos)>0 )
  457.                 c=line[t-1], line[t-1]=line[t], line[t]=c;
  458.             redraw();
  459.             break;
  460.         }
  461.         if( fn!=-2 )
  462.             LastFn=fn, LastKey=key;
  463.     }
  464.     ret=NULL;
  465. done:
  466.     if( ret )
  467.         printf("\033[%dC\n", Len-Pos );
  468.     newwidth();
  469.     if( eav ) free_expand(eav);
  470.     SETCON;
  471.     return ret;
  472. }
  473.  
  474. static int
  475. getkey(void)
  476. {
  477.     int   esc=0, key, c;
  478.     long *par;
  479.  
  480.     key=-1;
  481.     if( (c=myget())==27 ) {
  482.         esc=ESC;
  483.         if((c=myget())=='[')
  484.             c=155, esc=0;
  485.     }
  486.  
  487.     if(c!=155)
  488.         key=c;
  489.     else {
  490.         switch(c=myget()) {
  491.         case 'A': key=256;       break; /* CursUp */
  492.         case 'B': key=257;       break; /* CursDn */
  493.         case 'C': key=258;       break; /* CursRt */
  494.         case 'D': key=259;       break; /* CursLt */
  495.         case 'T': key=256+SHIFT; break; /* SCursUp */
  496.         case 'S': key=257+SHIFT; break; /* SCursDn */
  497.         case ' ':
  498.             switch( myget() ) {
  499.             case '@': key=258+SHIFT; break; /* SCursRt */
  500.             case 'A': key=259+SHIFT; break; /* SCursLt */
  501.             }
  502.             break;
  503.         case 'Z': key= 9+SHIFT;       break; /* STab    */
  504.         case '?': key= 260; myget();  break; /* Help    */
  505.         case -1 : return -99;
  506.         default :
  507.             if( c>='0' && c<='9' ) {
  508.                 myunget(c);
  509.                 par=Param;
  510.                 do {
  511.                     for( *par=0; (c=myget())>='0' && c<='9';  )
  512.                         *par=10* *par + c-'0';
  513.                     par++;
  514.                 } while( c==';' );
  515.                 if( c=='~' ) {
  516.                     key=Param[0]+261;
  517.                     if( key>270 ) key+=SHIFT-10;
  518.                 }
  519.                 if( c=='|' ) key=271;
  520.             } else
  521.                 key=c;
  522.         }
  523.     }
  524.  
  525.     return key+esc;
  526. }
  527.  
  528. static void
  529. back(int n)
  530. {
  531.     if( n>0 ) printf("\033[%dD",n);
  532. }
  533.  
  534. static void
  535. left(int n)
  536. {
  537.     if( n>Pos ) n=Pos;
  538.     if( n<=0  ) return;
  539.     back(n);
  540.     Pos-=n;
  541. }
  542.  
  543. static void
  544. right(int n)
  545. {
  546.     if( n+Pos>Len ) n=Len-Pos;
  547.     if( n<=0      ) return;
  548.     printf("\033[%dC",n);
  549.     Pos+=n;
  550. }
  551.  
  552. static int
  553. leftwordlen( void )
  554. {
  555.     char  *ptr= Line+Pos;
  556.     while( ptr>Line && *(ptr-1) == ' ' ) ptr--; 
  557.     while( ptr>Line && *(ptr-1) != ' ' ) ptr--;
  558.     return (Line+Pos)-ptr;
  559. }
  560.  
  561. static int
  562. rightwordlen( void )
  563. {
  564.     char  *ptr= Line+Pos;
  565.     while( ptr<Line+Len && *ptr != ' ' ) ptr++;
  566.     while( ptr<Line+Len && *ptr == ' ' ) ptr++; 
  567.     return ptr-(Line+Pos);
  568. }
  569.  
  570. static void
  571. delete( int cnt )
  572. {
  573.     if( !cnt ) return;
  574.     memmove( Line+Pos, Line+Pos+cnt, Len-Pos-cnt );
  575.     memset ( Line+Len-cnt, ' ', cnt );
  576.     printf("%s",Line+Pos);
  577.     back(Len-Pos);
  578.     Line[ Len-=cnt ]=0;
  579. }
  580.  
  581. static void
  582. history( int hnum )
  583. {
  584.     HIST *hist;
  585.  
  586.     for( hist=H_head; hist && hnum--; hist=hist->next) ;
  587.     display( hist ? hist->line : "");
  588. }
  589.  
  590. static void 
  591. display( char *str )
  592. {
  593.     left(Pos);
  594.     strcpy(Line,str);
  595.     printf("\033[J%s",str);
  596.     Pos= Len= strlen(str);
  597. }
  598.  
  599. static void
  600. redraw( void )
  601. {
  602.     back(Pos);
  603.     printf("\015\033[J%s%s",Prompt,Line);
  604.     back(Len-Pos);
  605. }
  606.  
  607. static int wleft, wdel;
  608.  
  609. static void
  610. getword( char *buf )
  611. {
  612.     char *beg, *end, *l=Line;
  613.  
  614.     for( end=l+Pos; *end  && *end!=' '; ++end ) ;
  615.     for( beg=l+Pos; beg>l && !index(" <>;",*(beg-1)) ; beg-- ) ;
  616.     memcpy( buf, beg, end-beg );
  617.     buf[end-beg]=0;
  618.     wleft= (l+Pos)-beg;
  619.     wdel = end-beg;
  620. }
  621.  
  622. static void
  623. delword()
  624. {
  625.     left( wleft);
  626.     delete( wdel );
  627. }
  628.  
  629.  
  630.  
  631. static void
  632. abbrev( char *buf, char **eav, int eac )
  633. {
  634.     int i, j, radlen=9999;
  635.  
  636.     if( eac>1 ) putchar( CTRL+'G' );
  637.  
  638.     strcpy( buf, eav[0] );
  639.     for( i=0; i<eac; i++ ) {
  640.         if ( (j=strlen(eav[i])) < radlen ) radlen=j;
  641.         for( j=0; j<radlen && tolower(eav[0][j])==tolower(eav[i][j]); j++ ) ;
  642.         if ( j<radlen ) radlen=j;
  643.     }
  644.     buf[radlen]=0;
  645. }
  646.  
  647. static void
  648. quote( char *buf, char *sep )
  649. {
  650.     int len=strlen(buf), dir=isdir(buf);
  651.  
  652.     if( hasspace(buf)) {
  653.         memmove(buf+1,buf,len);
  654.         buf[0]=buf[++len]='\"';
  655.         buf[++len]=0;
  656.     }
  657.     strcat(buf, dir ? "/" : sep );
  658. }
  659.  
  660. void
  661. setrawcon( long flag, int ievent ) /* -1L=RAW:, 0L=CON: */
  662. {
  663.     static char menuon, button;
  664.     long packargs[8];
  665.  
  666.     if( !o_nowindow && ievent && flag==0 && menuon)
  667.         printf("\033[10}"), menuon=0;
  668.  
  669.     packargs[0]=flag;
  670.     SendPacket(994L, packargs, (void *)Myprocess->pr_ConsoleTask);
  671.  
  672.     if( !o_nowindow && ievent && flag==-1 ) {
  673.         if( !menuon )
  674.             printf("\033[10{"), menuon=1;
  675.         if( !button )
  676.             printf("\033[11{"), button=1;
  677.     }
  678.     fflush(stdout);
  679. }
  680.  
  681.  
  682. static int row, height, cnt;
  683. static char scrollstr[10];
  684. static int noquick=1;
  685.  
  686.  
  687. extern BPTR OldCin;
  688.  
  689. static int FromTee;
  690.  
  691. static UBYTE
  692. mygetchar(void)
  693. {
  694.     UBYTE c;
  695.     Read( Input(), &c, 1 );
  696.     return c;
  697. }
  698.  
  699. void
  700. prepscroll( int fromtee )
  701. {
  702.     BPTR truecin=0;
  703.     long param[8];
  704.  
  705.     row=height=0;
  706.     FromTee=fromtee;
  707.  
  708.     if(( noquick=!o_scroll || o_noraw || o_nofastscr))
  709.         return;
  710.     if(( noquick=!isconsole(Myprocess->pr_COS) && !fromtee ))
  711.         return;
  712.     if( !isconsole(Myprocess->pr_CIS)) {
  713.         truecin=Myprocess->pr_CIS;
  714.  
  715.         if( noquick=!isconsole(OldCin) )
  716.             return;
  717.  
  718.         Myprocess->pr_CIS = DEVTAB(stdin) = OldCin;
  719.     }
  720.  
  721.     if( !CHARSWAIT(stdin) ) {
  722.         SETRAW;
  723.         Write(OldCin,"\033[ q",4);
  724.         get_seq( param );
  725.         height=param[2];
  726.         while( mygetchar()!='r') ;
  727.  
  728.         Write(OldCin,"\033[6n",4);
  729.         get_seq( param );
  730.         row=param[0];
  731.  
  732.         SETCON;
  733.  
  734.         cnt= height-row+1;
  735.         noquick= height<o_minrows;
  736.     }
  737.  
  738.     sprintf(scrollstr,"\033[%cS\033[%cA", o_scroll+'0', o_scroll+'0');
  739.  
  740.     if( truecin )
  741.         Myprocess->pr_CIS = DEVTAB(stdin) = truecin;
  742. }
  743.  
  744. static int
  745. get_seq( long *param )
  746. {
  747.     int c;
  748.  
  749.     while( (c=mygetchar())!=155 ) ;
  750.     do {
  751.         *param=0;
  752.         while( (c=mygetchar())>='0' && c<='9' )
  753.             *param=10* *param + c-'0';
  754.         param++;
  755.     } while( c==';' );
  756.  
  757.     return c;
  758. }
  759.  
  760.  
  761. void
  762. quickscroll( void )
  763. {
  764.     if( noquick ) return;
  765.  
  766.     if( --cnt<=0 ) {
  767.         cnt=o_scroll;
  768.         fprintf( FromTee ? stderr : stdout, "%s",scrollstr);
  769.     }
  770. }
  771.  
  772. int
  773. do_keymap( void )
  774. {
  775.     int i, n, len;
  776.     USHORT *tmp, *put, *get, *map;
  777.     char   *ind;
  778.  
  779. #if 0
  780.     if( ac==1 ) {
  781.         for( get=Keymap[0]; *get; get+=2 )
  782.             printf("%4d %4d\n",get[0],get[1]);
  783.         return 0;
  784.     }
  785. #endif
  786.  
  787.     n=myatoi(av[1],0,7);
  788.     if( atoierr ) return 20;
  789.  
  790.     map=Keymap[n]; len=0;
  791.     if( map )
  792.         for( len=0; map[2*len]; len++ ) ;
  793.  
  794.     put=tmp=salloc((len+ac)*2*sizeof(USHORT));
  795.     for( i=2; i<ac; i++ ) {
  796.         if( !(ind=index(av[i],'='))) {
  797.             ierror( av[i],500);
  798.             free( tmp );
  799.             return 20;
  800.         }
  801.         *put++=atoi(av[i]);
  802.         *put++=atoi(ind+1);
  803.     }
  804.  
  805.     for( i=0; i<len; i++ ) {
  806.         for( get=tmp; get<put; get+=2 )
  807.             if( *get==map[2*i] )
  808.                 break;
  809.         if( get==put ) {
  810.             *put++=map[2*i];
  811.             *put++=map[2*i+1];
  812.         }
  813.     }
  814.     *put++=0;
  815.     *put  =0;
  816.  
  817.     if( map && map!=DefKeymap0 && map!=DefKeymap1 )
  818.         free( map );
  819.     Keymap[n]=tmp;
  820.     Curmap=0;
  821.  
  822.     return 0;
  823. }
  824.  
  825. static int
  826. myget( void )
  827. {
  828.     int c;
  829.  
  830.     if( unget )
  831.         c=unget, unget=0;
  832.     else if( tyahdptr && *tyahdptr ) {
  833.         c=*tyahdptr++;
  834.     } else {
  835.         tyahdptr=NULL;
  836.         fflush(stdout);
  837.         c=getchar();
  838.     }
  839.  
  840.     return c;
  841. }
  842.  
  843. static void
  844. myunget(int c)
  845. {
  846.     unget=c;
  847. }
  848.  
  849. int
  850. newwidth( void )
  851. {
  852.     extern struct Window *Win;
  853.  
  854.     w_width = 80;
  855.     w_height= 24;
  856.     if( !o_nowindow && Win ) {
  857.         w_width =(Win->Width - Win->BorderLeft - Win->BorderRight)/
  858.                   Win->RPort->TxWidth;
  859.         w_height=(Win->Height- Win->BorderTop  - Win->BorderBottom)/
  860.                   Win->RPort->TxHeight;
  861.     }
  862.     if( w_width<1 ) w_width=1;          /* crash after resizing was reported */
  863.     return w_width;
  864. }
  865.  
  866.  
  867.  
  868. #else
  869.  
  870. void prepscroll(int fromtee) {}
  871. void quickscroll(void) {}
  872. int  do_keymap( void ) {}
  873. void setrawcon( long flag, int ievent ) {}
  874. int  newwidth( void ) {}
  875. void initmap(void) {}
  876.  
  877. #endif
  878.  
  879. extern struct MsgPort *Console;
  880.  
  881. int
  882. isconsole( BPTR fh )
  883. {
  884.     return ((struct FileHandle *)(4*fh))->fh_Type==Console &&
  885.         IsInteractive(fh);
  886. }
  887.